import java.util.Arrays;

public class TestDome1 {


    /**
     * 快速排序
     * 时间复杂度：
     * 最好【每次可以均匀的分割待排序序列】：O(N*logn)
     * 最坏：数据有序 或者逆序的情况 O(N^2)
     * 空间复杂度：
     * 最好：O(logn)
     * 最坏：O(n)   单分支的一棵树
     * 稳定性：不稳定的排序
     * @param array
     */
    public static void quicklly(int [] array){
        quickly(array,0,array.length-1);
    }
    public static void quickly(int[] array, int start, int end){
        if(start >= end){
            return;
        }
        int priot = quick(array,start,end);
        quickly(array,start,priot-1);
        quickly(array,priot+1,end);
    }
    public static int quick(int[] array, int left,int right){
        int tmp = array[left];
        while(left < right){
            while(left < right && array[right] >= tmp){
                right--;
            }
            array[left] = array[right];
            while(left < right && array[left] <= tmp){
                left++;
            }
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }

    /**
     * 冒泡排序
     * 时间复杂度：O(N^2)
     * 有序情况下：O(n)
     * 空间复杂度：O(1)
     * @param array
     */
    public static void mao(int[] array){
        for (int i = 0; i < array.length; i++) {
            boolean flg = false;
            for(int j = 0; j < array.length-1-i;j++){
                if(array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flg = true;
                }
            }
            if(flg = false){
                break;
            }
        }
    }
    public static void main(String[] args) {
        int[] array = {12,34,2,5,23,57};
        quicklly(array);
        System.out.println(Arrays.toString(array));
    }
}
